#Scenarios
# PROCEDURE global LP_MODEL_VERIFICATION_LOCAL_SCENARIO
# PROCEDURE global LP_ME_PUSH_MODELSET_SCENARIO nObjId: integer
# PROCEDURE global LP_START_MODEL_VERIFICATION_SCENARIO sModelSetID: string result: reference
# PROCEDURE global LP_ASK_MODEL_VERIFICATION_RESULTS_SCENARIO sVerificationID: string
# PROCEDURE global LP_OBTAIN_STATUS_COLOR_SCENARIO sVerificationID: string result: reference
# PROCEDURE global LP_OBTAIN_FEEDBACKS sModelSetID: string result: reference

# This scenario perform all the verification operations calling the verification component directly
PROCEDURE global LP_MODEL_VERIFICATION_LOCAL_SCENARIO {
    
    SETL lpHost:("http://127.0.0.1:9998/rest")

    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)
    SETL sZipToolName: ("7z.exe")
    SETL s7zipPath:(sTempFolder+sZipToolName)
    SETL sTempZipPath:(sTempFilename+".zip")

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)
    CC "AdoScript" FILE_COPY from: ("db:\\"+sZipToolName) to: (s7zipPath)

    #Get the available verifications
    LP_MV_GET_AVAILABLE_VERIFICATIONS lpHost:(lpHost) curlPath:(curlPath) result:sSupportedVerifications
    IF (sSupportedVerifications = "") {
        CC "AdoScript" ERRORBOX ("Error retriving the supported verifications")
        EXIT
    }

    #Select the verification to perform
    CC "AdoScript" LISTBOX entries: (sSupportedVerifications) toksep:"\n" title:"Verifications available" oktext:"Verify" boxtext:"Select a verification type:"
    IF (endbutton != "ok") {
        EXIT
    }
    SETL sVerificationToPerform:(selection)

    #choose the models
    CC "ImportExport" SHOW_EXPORT_DLG mode: "xml" title: "Select a Model Set to upload" filedescription: "zip" fileextension: "*.zip" filename: (sTempFilename+".zip")
    IF (endbutton != "ok") {
        EXIT
    }
    SETL sModelIDList:(modelids)
    SETL sTempZipPath:(filename)


    LP_EXPORT_MODELS_AS_LPZIP s7zipPath:(s7zipPath) curlPath:(curlPath) sModelIDList:(sModelIDList) sOutputPath:(sTempZipPath) result:zipStatus
    IF (zipStatus != "OK") {
        EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Created zip file: " + sTempZipPath)

    LP_MV_PUSH_MODEL_TO_VERIFIER lpHost:(lpHost) curlPath:(curlPath) sModelPath:(sTempZipPath) result:sModelID
    IF (sModelID = "") {
     CC "AdoScript" ERRORBOX ("Error uploading the models. Please check verification internal log")
     EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Uploaded model ID: "+sModelID)

    LP_MV_START_MODEL_VERIFICATION lpHost:(lpHost) curlPath:(curlPath) sModelSetId:(sModelID) sVerificationToPerform:(sVerificationToPerform) result:sVerificationID
    IF (sVerificationID = "") {
     CC "AdoScript" ERRORBOX ("Error starting verification. Please check verification internal log")
     EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Started verification ID: "+sVerificationID)

    #Wait till the verification is completed
    SETL sVerificationStatus: ("")
    WHILE (1) {
        LP_MV_GET_VERIFICATION_STATUS lpHost:(lpHost) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationStatus
        IF (sVerificationStatus = "") {
            CC "AdoScript" ERRORBOX ("Error in the verification phase. Please check verification internal log")
            EXIT
        }
        EVENT_LOG msgType:"EVENT_LOG" message: ("Verification Status: "+sVerificationStatus)
        IF (sVerificationStatus != "IN PROGRESS") {
            BREAK
        }
        CC "AdoScript" SLEEP ms: (2000)
    }
    IF (sVerificationStatus != "COMPLETED") {
        CC "AdoScript" ERRORBOX ("Error in the verification phase. Please check verification internal log. Verification Status: " + sVerificationStatus)
        EXIT
    }

    #Get the verification results
    LP_MV_GET_VERIFICATION_RESULTS lpHost:(lpHost) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationResult
    IF (sVerificationResult = "") {
        CC "AdoScript" ERRORBOX ("Error in the verification phase. Please check verification internal log")
        EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Verification Results: "+sVerificationResult)

    #Parse the xml results and show them on the model
    LP_SHOW_VERIFICATION_RESULTS verificationResult:(sVerificationResult)


}

# This scenario push the zip model in the LearnPAd platform
PROCEDURE global LP_ME_PUSH_MODELSET_SCENARIO nObjId: integer {
    
    SETL lpHost:("http://testbed.learnpad.eu/xwiki/rest")
    SETL lpUsername:("superadmin")
    SETL lpPassword:("LearnPAss")

    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)
    SETL sZipToolName: ("7z.exe")
    SETL s7zipPath:(sTempFolder+sZipToolName)

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)
    CC "AdoScript" FILE_COPY from: ("db:\\"+sZipToolName) to: (s7zipPath)
    
    CC "Core" GET_ATTR_VAL objid: (nObjId) attrname: ("Model Set Version")
    SETL nCurModelSetVersion: (VAL(val))
    CC "AdoScript" QUERYBOX "Is it new version of Model Set?" title: ("Versioning") yes-no
    SETL sIsNewVersion: (endbutton)
    IF (sIsNewVersion = "yes") {
        CC "AdoScript" LISTBOX "Is it new major or minor version of Model Set?" title: ("Versioning") entries: ("minor@major") toksep: ("@")
        IF (selection = "major") {
            SETL nCurModelSetVersion: (nCurModelSetVersion+1)
        }
        IF (endbutton = "cancel") {
            CC "AdoScript" ERRORBOX ("Process has been cancelled")
            EXIT
        } ELSE {
            SETL nCurModelSetVersion: (nCurModelSetVersion+0.1)
        }
        CC "Core" SET_ATTR_VAL objid: (nObjId) attrname: ("Model Set Version") val: (STR nCurModelSetVersion)
    }
    
    CC "Core" GET_ATTR_VAL objid: (nObjId) attrname: ("Model Set ID")
    SETL sModelSetId:(val)
    
    CC "Core" GET_MODEL_ID objid: (nObjId)
    SETL nOverviewModelId:(modelid)
    
    #choose the models
    CC "Core" EVAL_EXPRESSION (irtmodels ((nObjId), "Model Set"))
    SETL sModelIDs:(STR(nOverviewModelId)+" "+(result))

    CC "Core" SET_ATTR_VAL objid: (nObjId) attrname: ("IsSelected") val: ("true")
    
    SETL sTempZipPath:(sTempFolder+sModelSetId+".zip")

    LP_EXPORT_MODELS_AS_LPZIP s7zipPath:(s7zipPath) curlPath:(curlPath) sModelIDList:(sModelIDs) sOutputPath:(sTempZipPath) result:sRes
    IF (sRes != "OK") {
        EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Created zip file: " + sTempZipPath)
    
    LP_ME_PUSH_MODELSET lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sModelPath:(sTempZipPath) sModelSetId:(sModelSetId) result:sRes
    EVENT_LOG msgType:"EVENT_LOG" message: ("Uploaded results:\n\n"+sRes)
}

# This scenario require a modelset id as input and start the verification returning the verification id
PROCEDURE global LP_START_MODEL_VERIFICATION_SCENARIO sModelSetID: string result: reference {
    
    SETL lpHost:("http://testbed.learnpad.eu/xwiki/rest")
    SETL lpUsername:("superadmin")
    SETL lpPassword:("LearnPAss")
    
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)

    #Get the available verifications
    LP_ME_GET_AVAILABLE_VERIFICATIONS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) result:sSupportedVerifications
    IF (sSupportedVerifications = "") {
        CC "AdoScript" ERRORBOX ("Error retriving the supported verifications")
        SETL result:("")
        EXIT
    }

    #Select the verification to perform
    CC "AdoScript" LISTBOX entries: (sSupportedVerifications) toksep:"\n" title:"Verifications available" oktext:"Verify" boxtext:"Select a verification type:"
    IF (endbutton != "ok") {
        SETL result:("")
        EXIT
    }
    SETL sVerificationToPerform:(selection)

    LP_ME_START_MODEL_VERIFICATION lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sModelSetId:(sModelSetID) sVerificationToPerform:(sVerificationToPerform) result:sVerificationID
    IF (sVerificationID = "") {
     CC "AdoScript" ERRORBOX ("Error starting verification. Please check verification internal log")
     SETL result:("")
     EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Started verification ID: "+sVerificationID)

    SETL result:(sVerificationID)
}

# This scenario require a verification id as input and show the verification results on the model
PROCEDURE global LP_ASK_MODEL_VERIFICATION_RESULTS_SCENARIO sVerificationID: string {
    
    SETL lpHost:("http://testbed.learnpad.eu/xwiki/rest")
    SETL lpUsername:("superadmin")
    SETL lpPassword:("LearnPAss")
    
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)

    #Get the verification status
    LP_ME_GET_VERIFICATION_STATUS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationStatus
    IF (sVerificationStatus != "COMPLETED") {
        CC "AdoScript" ERRORBOX ("The verification is not yet completed.\n\nVerification Status: " + sVerificationStatus)
        EXIT
    }
    #Get the verification results
    LP_ME_GET_VERIFICATION_RESULTS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationResult
    IF (sVerificationResult = "") {
        CC "AdoScript" ERRORBOX ("Severe error in the verification phase with id " + sVerificationID)
        EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Verification Results: "+sVerificationResult)

    #Parse the xml results and show them on the model
    LP_SHOW_VERIFICATION_RESULTS verificationResult:(sVerificationResult)
}

#This scenario require a verification id as input and return a code associate to the result: -1 for severe errors in the verification phase, 0 for YELLOW (in progress), 1 for GREEN (good model), 2 for RED (bad model)
PROCEDURE global LP_OBTAIN_STATUS_COLOR_SCENARIO sVerificationID: string result: reference {
    
    SETL lpHost:("http://testbed.learnpad.eu/xwiki/rest")
    SETL lpUsername:("superadmin")
    SETL lpPassword:("LearnPAss")
    
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)

    #Get the verification status
    LP_ME_GET_VERIFICATION_STATUS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationStatus
    IF (sVerificationStatus = "NEVER STARTED") {
        SET result:(-1)
    } ELSIF (sVerificationStatus = "IN PROGRESS") {
        SET result:(0)
    } ELSIF (sVerificationStatus = "COMPLETED") {
        LP_ME_GET_VERIFICATION_RESULTS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sVerificationID:(sVerificationID) result:sVerificationResult
        IF (sVerificationResult = "") {
            SET result:(-1)
        } ELSE {
            XML_GETNODECHILD xmlNode:(sVerificationResult) nodeNumber:(3) result:xmlFinalResultNode
            XML_GETNODECONTENT xmlNode:(xmlFinalResultNode) result:xmlFinalResult
            IF (xmlFinalResult = "OK") {
                SET result:(1)
            } ELSE {
                SET result:(2)
            }
        }
    } ELSE {
        # Status not recognized
        SET result:(-1)
    }
}

#This scenario require a model set id as input and process the feedback obtained from the LearnPAd platform
PROCEDURE global LP_OBTAIN_FEEDBACKS sModelSetID: string result: reference {
    
    SETL lpHost:("http://testbed.learnpad.eu/xwiki/rest")
    SETL lpUsername:("superadmin")
    SETL lpPassword:("LearnPAss")
    
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFilename: (filename)
    SETL nPosFileName: (bsearch ( sTempFilename , "\\" , (LEN sTempFilename)-1 ))
    SETL sTempFolder: (copy ( sTempFilename , 0 , nPosFileName+1 ))
    SETL sRestClientName: ("curl.exe")
    SETL curlPath:(sTempFolder+sRestClientName)

    CC "AdoScript" FILE_COPY from: ("db:\\"+sRestClientName) to: (curlPath)

    #Get the feedback results
    LP_ME_GET_FEEDBACKS lpHost:(lpHost) lpUsername:(lpUsername) lpPassword:(lpPassword) curlPath:(curlPath) sModelSetId:(sModelSetID) result:sFeedbacks
    IF (sFeedbacks = "") {
        CC "AdoScript" ERRORBOX ("An error occurred while retriving feedbacks for the model set " + sModelSetID)
        EXIT
    }
    EVENT_LOG msgType:"EVENT_LOG" message: ("Feedback Results: "+sFeedbacks)

    #parse the feedback xml and process the results
    LP_SHOW_FEEDBACKS_AND_PATCHES sFeedbacks:(sFeedbacks)
}



#LearnPAd Utils:
# PROCEDURE global LP_MV_GET_AVAILABLE_VERIFICATIONS lpHost: string curlPath: string result: reference
# PROCEDURE global LP_ME_GET_AVAILABLE_VERIFICATIONS lpHost: string lpUsername: string lpPassword: string curlPath: string result: reference
# PROCEDURE global LP_MV_PUSH_MODEL_TO_VERIFIER lpHost: string curlPath: string sModelPath: string result: reference
# PROCEDURE global LP_ME_PUSH_MODELSET lpHost: string sCredentials: string curlPath: string sModelPath: string sModelSetId: string result: reference
# PROCEDURE global LP_MV_START_MODEL_VERIFICATION lpHost: string curlPath: string sModelSetId: string sVerificationToPerform: string result: reference
# PROCEDURE global LP_ME_START_MODEL_VERIFICATION lpHost: string lpUsername: string lpPassword: string curlPath: string sModelSetId: string sVerificationToPerform: string result: reference
# PROCEDURE global LP_MV_GET_VERIFICATION_STATUS lpHost: string curlPath: string sVerificationID: string result: reference
# PROCEDURE global LP_ME_GET_VERIFICATION_STATUS lpHost: string lpUsername: string lpPassword: string curlPath: string sVerificationID: string result: reference
# PROCEDURE global LP_MV_GET_VERIFICATION_RESULTS lpHost: string curlPath: string sVerificationID: string result: reference
# PROCEDURE global LP_ME_GET_VERIFICATION_RESULTS lpHost: string lpUsername: string lpPassword: string curlPath: string sVerificationID: string result: reference
# PROCEDURE global LP_ME_GET_FEEDBACKS lpHost: string lpUsername: string lpPassword: string curlPath: string sModelSetId: string result: reference

#useful methods
# PROCEDURE global LP_CONVERT_XML xml: string result: reference
# PROCEDURE global LP_EXPORT_MODEL_AS_BPMN sModelID: string curlPath: string result: reference
# PROCEDURE global LP_EXPORT_MODELS_AS_LPZIP s7zipPath: string curlPath: string sModelIDList: string sOutputPath: string result: reference
# PROCEDURE global LP_SHOW_VERIFICATION_RESULTS verificationResult:string
# PROCEDURE global LP_SHOW_FEEDBACKS_AND_PATCHES sFeedbacks: string


#Get the available verifications as a string list separated by \n (calling MV directly without passing throught the LP platform)
PROCEDURE global LP_MV_GET_AVAILABLE_VERIFICATIONS lpHost: string curlPath: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_MV_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_MV_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/learnpad/mv/bridge/getavailableverifications\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILDCOUNT xmlNode:(sXml) result:numVerification
    SETL sSupportedVerifications:("")
    SETL count:(0)
    FOR count from:(0) to:(numVerification-1) {
        XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(count) result:sVerificationAvailableNode
        XML_GETNODECONTENT xmlNode:(sVerificationAvailableNode) result:sVerificationAvailable
        SETL sSupportedVerifications:(sSupportedVerifications + sVerificationAvailable + "\n")
    }
    IF (sSupportedVerifications != "") {
        SETL sSupportedVerifications:(copy(sSupportedVerifications, 0, LEN(sSupportedVerifications)-1))
    }
    
    SETL result:(sSupportedVerifications)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the available verifications as a string list separated by \n (calling the LP platflorm)
PROCEDURE global LP_ME_GET_AVAILABLE_VERIFICATIONS lpHost: string lpUsername: string lpPassword: string curlPath: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" -u \""+sCredentials+"\" \""+lpHost+"/learnpad/me/corefacade/checkmodelset/availableverifications\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILDCOUNT xmlNode:(sXml) result:numVerification
    SETL sSupportedVerifications:("")
    SETL count:(0)
    FOR count from:(0) to:(numVerification-1) {
        XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(count) result:sVerificationAvailableNode
        XML_GETNODECONTENT xmlNode:(sVerificationAvailableNode) result:sVerificationAvailable
        SETL sSupportedVerifications:(sSupportedVerifications + sVerificationAvailable + "\n")
    }
    IF (sSupportedVerifications != "") {
        SETL sSupportedVerifications:(copy(sSupportedVerifications, 0, LEN(sSupportedVerifications)-1))
    }
    
    SETL result:(sSupportedVerifications)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Push the model to the local model verificator WS and return the ID assigned to the model (calling MV directly without passing throught the LP platform)
PROCEDURE global LP_MV_PUSH_MODEL_TO_VERIFIER lpHost: string curlPath: string sModelPath: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_MV_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_MV_TRACE")
    
    CC "AdoScript" PERCWIN_CREATE title: ("Sending the file to the LearnPAd Model Verificator. Please wait...")
    CC "AdoScript" PERCWIN_SET percentage:(50)
    
    
    SYSTEM ( "cmd /c "+curlPath+" -X PUT --trace-ascii \""+sTempTraceFilePath+"\" -H \"Content-Type: application/octet-stream\" --compress --data-binary @\""+sModelPath+"\" \""+lpHost+"/learnpad/mv/bridge/loadmodel\">"+sTempOutputFilePath)
    
    CC "AdoScript" PERCWIN_SET percentage:(100)
    CC "AdoScript" PERCWIN_DESTROY
    
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL sId:(text)
    SETL result:(sId)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Push a model to the LearnPAd platform
PROCEDURE global LP_ME_PUSH_MODELSET lpHost: string lpUsername: string lpPassword: string curlPath: string sModelPath: string sModelSetId: string result: reference {
    SETL sModelSetType:("lpzip")
    
    CC "AdoScript" PERCWIN_CREATE title: ("Sending the file to the LearnPAd platform. Please wait...")
    CC "AdoScript" PERCWIN_SET percentage:(50)
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -X PUT -u \""+sCredentials+"\" --trace-ascii \""+sTempTraceFilePath+"\" -H \"Content-Type: application/octet-stream\" --compress --data-binary @\""+sModelPath+"\" \""+lpHost+"/learnpad/me/corefacade/importmodelset/"+sModelSetId+"?type="+sModelSetType+"\">"+sTempOutputFilePath)
    
    CC "AdoScript" PERCWIN_SET percentage:(100)
    CC "AdoScript" PERCWIN_DESTROY
    
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL result:(text)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    } ELSE {
        CC "AdoScript" FREAD file: (sTempTraceFilePath)
        SETL result:(text)
    }
}

#Start the model verification and return the Id assigned to the verification process (calling MV directly without passing throught the LP platform)
PROCEDURE global LP_MV_START_MODEL_VERIFICATION lpHost: string curlPath: string sModelSetId: string sVerificationToPerform: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_MV_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_MV_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/learnpad/mv/bridge/startverification\" --data-urlencode \"verificationtype="+sVerificationToPerform+"\" --data-urlencode \"modelsetid="+sModelSetId+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(0) result:sIdNode
    XML_GETNODECONTENT xmlNode:(sIdNode) result:sId
    #CC "AdoScript" debug INFOBOX (sId)

    SETL result:(sId)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Start the model verification and return the Id assigned to the verification process (calling the LP platflorm)
PROCEDURE global LP_ME_START_MODEL_VERIFICATION lpHost: string lpUsername: string lpPassword: string curlPath: string sModelSetId: string sVerificationToPerform: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    SETL sModelSetType:("lpzip")
    
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" -u \""+sCredentials+"\" \""+lpHost+"/me/corefacade/checkmodelset/start/"+sModelSetId+"\" --data-urlencode \"type="+sModelSetType+"\" --data-urlencode \"verification="+sVerificationToPerform+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(0) result:sIdNode
    XML_GETNODECONTENT xmlNode:(sIdNode) result:sId
    #CC "AdoScript" debug INFOBOX (sId)

    SETL result:(sId)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the status of the verification. It can be: NEVER STARTED, IN PROGRESS or COMPLETED (calling MV directly without passing throught the LP platform)
PROCEDURE global LP_MV_GET_VERIFICATION_STATUS lpHost: string curlPath: string sVerificationID: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_MV_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_MV_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/learnpad/mv/bridge/getverificationstatus\" --data-urlencode \"verificationprocessid="+sVerificationID+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(0) result:sStatusNode
    XML_GETNODECONTENT xmlNode:(sStatusNode) result:sVStatus
    #CC "AdoScript" debug INFOBOX (sVStatus)

    SETL result:(sVStatus)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the status of the verification. It can be: NEVER STARTED, IN PROGRESS or COMPLETED (calling the LP platflorm)
PROCEDURE global LP_ME_GET_VERIFICATION_STATUS lpHost: string lpUsername: string lpPassword: string curlPath: string sVerificationID: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    SYSTEM ( "cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" -u \""+sCredentials+"\" \""+lpHost+"/me/corefacade/checkmodelset/check/"+sVerificationID+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    
    SETL sXml:(text)
    XML_GETNODECHILD xmlNode:(sXml) nodeNumber:(0) result:sStatusNode
    XML_GETNODECONTENT xmlNode:(sStatusNode) result:sVStatus
    #CC "AdoScript" debug INFOBOX (sVStatus)

    SETL result:(sVStatus)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the results of the verification (to be called only when the status is COMPLETED) (calling MV directly without passing throught the LP platform)
PROCEDURE global LP_MV_GET_VERIFICATION_RESULTS lpHost: string curlPath: string sVerificationID: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempOutputFilePath:(filename+".LP_MV_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_MV_TRACE")
    SYSTEM ("cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/learnpad/mv/bridge/getverificationresult\" --data-urlencode \"verificationprocessid="+sVerificationID+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL sVResults:(text)
    #CC "AdoScript" debug INFOBOX (sVResults)
    SETL result:(sVResults)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the results of the verification (to be called only when the status is COMPLETED) (calling the LP platflorm)
PROCEDURE global LP_ME_GET_VERIFICATION_RESULTS lpHost: string lpUsername: string lpPassword: string curlPath: string sVerificationID: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    SYSTEM ("cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/me/corefacade/checkmodelset/results/"+sVerificationID+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL sVResults:(text)
    #CC "AdoScript" debug INFOBOX (sVResults)
    SETL result:(sVResults)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}

#Get the feedbacks for the provided model set id
PROCEDURE global LP_ME_GET_FEEDBACKS lpHost: string lpUsername: string lpPassword: string curlPath: string sModelSetId: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    
    SETL sCredentials:(lpUsername+":"+lpPassword)
    
    SETL sTempOutputFilePath:(filename+".LP_ME_OUTPUT")
    SETL sTempTraceFilePath:(filename+".LP_ME_TRACE")
    SYSTEM ("cmd /c "+curlPath+" -G --trace-ascii \""+sTempTraceFilePath+"\" \""+lpHost+"/me/corefacade/retrievefeedbacks/"+sModelSetId+"\">"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL sFeedbacks:(text)
    #CC "AdoScript" debug INFOBOX (sFeedbacks)
    SETL result:(sFeedbacks)
    IF (result != "") {
        CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)
        CC "AdoScript" FILE_DELETE file: (sTempTraceFilePath)
    }
}




#Useful methods

#Convert the full model in uppercase in order to be compliant with the DTD schema adoxml31.dtd
PROCEDURE global LP_CONVERT_XML xml: string result: reference {
    SETL xml:(replall(xml, "<adoxml", "<ADOXML"))
    SETL xml:(replall(xml, "</adoxml", "</ADOXML"))
    SETL xml:(replall(xml, "<models", "<MODELS"))
    SETL xml:(replall(xml, "</models", "</MODELS"))
    SETL xml:(replall(xml, "<attrprofdir", "<ATTRPROFDIR"))
    SETL xml:(replall(xml, "</attrprofdir", "</ATTRPROFDIR"))
    SETL xml:(replall(xml, "<attributeprofiles", "<ATTRIBUTEPROFILES"))
    SETL xml:(replall(xml, "</attributeprofiles", "</ATTRIBUTEPROFILES"))
    SETL xml:(replall(xml, "<attributeprofile", "<ATTRIBUTEPROFILE"))
    SETL xml:(replall(xml, "</attributeprofile", "</ATTRIBUTEPROFILE"))
    SETL xml:(replall(xml, "<modelgroups", "<MODELGROUPS"))
    SETL xml:(replall(xml, "</modelgroups", "</MODELGROUPS"))
    SETL xml:(replall(xml, "<modelgroup", "<MODELGROUP"))
    SETL xml:(replall(xml, "</modelgroup", "</MODELGROUP"))
    SETL xml:(replall(xml, "<modelreference", "<MODELREFERENCE"))
    SETL xml:(replall(xml, "</modelreference", "</MODELREFERENCE"))
    SETL xml:(replall(xml, "<modelattributes", "<MODELATTRIBUTES"))
    SETL xml:(replall(xml, "</modelattributes", "</MODELATTRIBUTES"))
    SETL xml:(replall(xml, "<model id=\"", "<MODEL id=\"mod.")) #fix: model id have to start with a word for DTD validation
    SETL xml:(replall(xml, "</model", "</MODEL"))
    SETL xml:(replall(xml, "<attribute", "<ATTRIBUTE"))
    SETL xml:(replall(xml, "</attribute", "</ATTRIBUTE"))
    SETL xml:(replall(xml, "<record", "<RECORD"))
    SETL xml:(replall(xml, "</record", "</RECORD"))
    #fix record additional attributes (rowcount and skippedrows) that must not be present for DTD validation
    WHILE (search(xml, "rowcount", 0) != -1) {
        SETL nStart:(search(xml, " rowcount", 0))
        SETL nEnd:(search(xml, ">", nStart))
        SETL sRECORDAttributes:(copy(xml, nStart, nEnd-nStart))
        SETL xml:(replall(xml, sRECORDAttributes, ""))
    }
    SETL xml:(replall(xml, "<instance", "<INSTANCE"))
    SETL xml:(replall(xml, "</instance", "</INSTANCE"))
    SETL xml:(replall(xml, "<interref", "<INTERREF"))
    SETL xml:(replall(xml, "</interref", "</INTERREF"))
    SETL xml:(replall(xml, "<iref", "<IREF"))
    SETL xml:(replall(xml, "</iref", "</IREF"))
    SETL xml:(replall(xml, "<connector", "<CONNECTOR"))
    SETL xml:(replall(xml, "</connector", "</CONNECTOR"))
    SETL xml:(replall(xml, "<from", "<FROM"))
    SETL xml:(replall(xml, "</from", "</FROM"))
    SETL xml:(replall(xml, "<to", "<TO"))
    SETL xml:(replall(xml, "</to", "</TO"))
    SETL xml:(replall(xml, "<row", "<ROW"))
    SETL xml:(replall(xml, "</row", "</ROW"))

    SETL result:(xml)
}

#Export the specified model in BPMN Standard
PROCEDURE global LP_EXPORT_MODEL_AS_BPMN sModelID: string curlPath: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempInputFilePath:(filename+".WS_BPMN_INPUT")
    SETL sTempOutputFilePath:(filename+".WS_BPMN_OUTPUT")
    
    CC "Core" GET_MODEL_MODELTYPE modelid: (VAL(sModelID))
    IF (modeltype != "Business process diagram (BPMN 2.0)") {
        SETL result:("")
        EXIT
    }
    
    #export the single model
    CC "Documentation" XML_MODELS modelids: (sModelID) mgroupids: ("") attrprofs: ("") apgroups: ("") 
    IF (ecode != 0) {
        CC "AdoScript" ERRORBOX ("Error exporting the model " + sModelID)
        SETL result:("")
        EXIT
    }
    
    SETL sXml:(xml)
    SETL sXml:(replall(sXml, "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n", ""))
    SETL sXml:(replall(sXml, " xmlns=\"@boc-eu.com/boc-is/adonis.model.document;1\"", ""))
    SETL sXml:(replall(sXml, " xsi:schemaLocation=\"@boc-eu.com/boc-is/adonis.model.document;1 adoxmlmodel.xsd\"", ""))
    
    #Create the soap envelope request
    SETL sEnvelopeXml:("<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:ser=\"http://service.bpmn.adows.adoxx.org/\"><soapenv:Header/><soapenv:Body><ser:transformADOXML2BPMN><inputADOxxXML><![CDATA["+sXml+"]]></inputADOxxXML><modelid>"+sModelID+"</modelid></ser:transformADOXML2BPMN></soapenv:Body></soapenv:Envelope>")
    CC "AdoScript" FWRITE file: (sTempInputFilePath) text: (sEnvelopeXml) append: 0 binary: 0 base64: 0
    
    #call the ws
    SYSTEM ("cmd /c "+curlPath+" -k --header \"Content-Type: text/xml;charset=UTF-8\" --header \"SOAPAction:urn:TransformADOXML2BPMN\" --data @"+sTempInputFilePath+" https://www.adoxx.org/ADOxxORGBPMNExport/services/transformbpmn >"+sTempOutputFilePath)
    CC "AdoScript" FREAD file: (sTempOutputFilePath)
    SETL sBPMNEnvelope: (text)
    IF (sBPMNEnvelope = "") {
        CC "AdoScript" ERRORBOX ("Error calling the web service")
        SETL result:("")
        EXIT
    }
    
    #get the result
    SETL nStart:(search(sBPMNEnvelope, "<outputBPMN>", 0)+LEN("<outputBPMN>"))
    SETL nEnd:(search(sBPMNEnvelope, "</outputBPMN>", 0))
    SETL sBPMN:(copy(sBPMNEnvelope, nStart, nEnd-nStart))
    IF (sBPMN = "") {
        CC "AdoScript" ERRORBOX ("Error: The web service returned no data for the model "+sModelID+":\ninput:"+sTempInputFilePath+"\noutput:"+sTempOutputFilePath)
        SETL result:("")
        EXIT
    }
    
    #xml unesacape
    SETL sBPMN:(replall(sBPMN, "&gt;", ">"))
    SETL sBPMN:(replall(sBPMN, "&lt;", "<"))
    SETL sBPMN:(replall(sBPMN, "&amp;", "&"))
    SETL sBPMN:(replall(sBPMN, "&apos;", "'"))
    SETL sBPMN:(replall(sBPMN, "&quot;", "\""))
    
    CC "AdoScript" FILE_DELETE file: (sTempInputFilePath)
    CC "AdoScript" FILE_DELETE file: (sTempOutputFilePath)

    SETL result:(sBPMN)
}

#Create a ZIP File containing the XML and the BPMN. Return "OK" if the process terminate without errors
PROCEDURE global LP_EXPORT_MODELS_AS_LPZIP s7zipPath: string curlPath: string sModelIDList: string sOutputPath: string result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFolder:(copy(filename, 0, bsearch(filename, "\\", (LEN filename)-1)+1))

    SETL sTempModelSetPath:(sTempFolder+"adoxx_modelset.xml")
    #SETL sTempModelSetPath:(filename+".xml")
    
    CC "AdoScript" PERCWIN_CREATE title: ("Creation of the ZIP file. Please wait...") with-cancel-button
    
    #Export the whole xml
    CC "Documentation" XML_MODELS modelids: (sModelIDList) mgroupids: ("") attrprofs: ("") apgroups: ("") 
    IF (ecode != 0) {
        CC "AdoScript" ERRORBOX ("Error exporting the models")
        CC "AdoScript" PERCWIN_DESTROY
        SETL result:("KO")
        EXIT
    }
    
    #Convert the full model in uppercase in order to be compliant with the DTD schema adoxml31.dtd
    LP_CONVERT_XML xml:(xml) result:xml
    
    SETL sFullXml:(xml)
    SETL sFullXml:(replall(sFullXml, "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n", ""))
    SETL sFullXml:(replall(sFullXml, " xmlns=\"@boc-eu.com/boc-is/adonis.model.document;1\"", ""))
    SETL sFullXml:(replall(sFullXml, " xsi:schemaLocation=\"@boc-eu.com/boc-is/adonis.model.document;1 adoxmlmodel.xsd\"", ""))
    SETL sFullXml:(replall(sFullXml, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"", ""))
    CC "AdoScript" FWRITE file: (sTempModelSetPath) text: (sFullXml) append: 0 binary: 0 base64: 0
    CC "AdoScript" FREAD file: (sTempModelSetPath)
    IF (text = "") {
        CC "AdoScript" ERRORBOX ("Failure on the creation of the file: " + sTempModelSetPath)
        CC "AdoScript" PERCWIN_DESTROY
        SETL result:("KO")
        EXIT
    }
    
    CC "AdoScript" PERCWIN_IS_CANCELED
    IF (canceled) {
        CC "AdoScript" PERCWIN_DESTROY
        SETL result:("KO")
        EXIT
    }
    CC "AdoScript" PERCWIN_SET percentage:(10) 
    
    SETL sBPMNModelIDs:("")
    
    SETL nTotModels:(tokcnt(sModelIDList))
    SETL nModelCounter:(1)
    #Process each model
    FOR sModelID in: (sModelIDList) {
        CC "Core" GET_MODEL_MODELTYPE modelid: (VAL(sModelID))
        IF (modeltype = "Business process diagram (BPMN 2.0)") {
            
            LP_EXPORT_MODEL_AS_BPMN sModelID:(sModelID) curlPath:(curlPath) result: sBPMN
            IF (sBPMN = "") {
                CC "AdoScript" PERCWIN_DESTROY
                SETL result:("KO")
                EXIT
            }
        
            #store the result
            SETL sTempBPMNPath:(sTempFolder+sModelID+".bpmn")
            CC "AdoScript" FWRITE file: (sTempBPMNPath) text: (sBPMN) append: 0 binary: 0 base64: 0
            CC "AdoScript" FREAD file: (sTempBPMNPath)
            IF (text = "") {
                CC "AdoScript" ERRORBOX ("Failure on the creation of the file: " + sTempBPMNPath)
                CC "AdoScript" PERCWIN_DESTROY
                SETL result:("KO")
                EXIT
            }
            SETL sBPMNModelIDs:(sBPMNModelIDs + sModelID + " ")
        }
        
        #model have to be loaded in order to generate graphics
        CC "Core" LOAD_MODEL modelid:(VAL(sModelID))
        #create images
        SETL sTempImagePath:(sTempFolder + sModelID + ".png")
        CC "Drawing" GEN_GFX_FILE modelid:(VAL(sModelID)) filename:(sTempImagePath) gfx-format:("png")
        CC "AdoScript" FREAD file: (sTempImagePath)
        IF (text = "") {
            CC "AdoScript" ERRORBOX ("Failure on the creation of the file: " + sTempImagePath)
            CC "AdoScript" PERCWIN_DESTROY
            SETL result:("KO")
            EXIT
        }
        #create image maps
        SETL sTempImageMapPath:(sTempFolder+sModelID+".map")
        CC "Drawing" COMPUTE_REGION_IMAGE_MAP modelid: (VAL(sModelID)) scale: 1 with-swimlanes
        CC "AdoScript" FWRITE file: (sTempImageMapPath) text: (imgmap) append: 0 binary: 0 base64: 0
        CC "AdoScript" FREAD file: (sTempImageMapPath)
        IF (text = "") {
            CC "AdoScript" ERRORBOX ("Failure on the creation of the file: " + sTempImageMapPath)
            CC "AdoScript" PERCWIN_DESTROY
            SETL result:("KO")
            EXIT
        }
        
        CC "AdoScript" PERCWIN_IS_CANCELED
        IF (canceled) {
            CC "AdoScript" PERCWIN_DESTROY
            SETL result:("KO")
            EXIT
        }
        CC "AdoScript" PERCWIN_SET percentage:(((nModelCounter*80)/nTotModels)+10)
        
        SETL nModelCounter:(nModelCounter+1)
    }
    
    IF (sBPMNModelIDs != "") {
        SETL sBPMNModelIDs:(copy(sBPMNModelIDs, 0, LEN(sBPMNModelIDs)-1))
    }
    
    #create the zip file
    SETL s7ZCommand:("cmd /c "+s7zipPath+" a -tzip \""+sOutputPath+"\" \""+sTempModelSetPath+"\"")
    FOR sModelID in: (sBPMNModelIDs) {
        SETL s7ZCommand:(s7ZCommand+" \""+sTempFolder+sModelID+".bpmn"+"\"")
    }
    FOR sModelID in: (sModelIDList) {
        SETL s7ZCommand:(s7ZCommand+" \""+sTempFolder+sModelID+".png"+"\"")
        SETL s7ZCommand:(s7ZCommand+" \""+sTempFolder+sModelID+".map"+"\"")
    }

    CC "AdoScript" FILE_DELETE file:(sOutputPath)
    SYSTEM (s7ZCommand) result:res
    CC "AdoScript" FREAD file: (sOutputPath)
    IF (text = "") {
        CC "AdoScript" ERRORBOX ("Error executing the zip command:\n"+s7ZCommand)
        CC "AdoScript" PERCWIN_DESTROY
        SETL result:("KO")
        EXIT
    }

    FOR sModelID in: (sBPMNModelIDs) {
        SETL sTempBPMNPath:(sTempFolder+sModelID+".bpmn")
        CC "AdoScript" FILE_DELETE file: (sTempBPMNPath)
    }
    FOR sModelID in: (sModelIDList) {
        CC "AdoScript" FILE_DELETE file: (sTempFolder+sModelID+".png")
        CC "AdoScript" FILE_DELETE file: (sTempFolder+sModelID+".map")
    }
    CC "AdoScript" FILE_DELETE file: (sTempModelSetPath)
    
    CC "AdoScript" PERCWIN_IS_CANCELED
    IF (canceled) {
        CC "AdoScript" PERCWIN_DESTROY
        SETL result:("KO")
        EXIT
    }
    
    CC "AdoScript" PERCWIN_SET percentage:(100)
    CC "AdoScript" PERCWIN_DESTROY
    
    SETL result:("OK")
}

#Parse the Verification results and show them on the model
PROCEDURE global LP_SHOW_VERIFICATION_RESULTS verificationResult: string {

    XML_GETNODECHILD xmlNode:(verificationResult) nodeNumber:(3) result:xmlFinalResultNode
    XML_GETNODECONTENT xmlNode:(xmlFinalResultNode) result:xmlFinalResult
    IF(xmlFinalResult = "OK") {
        CC "AdoScript" INFOBOX ("GOOD NEWS: All the models are correct")
    } ELSE {
        CC "AdoScript" ERRORBOX ("BAD NEWS: Seems that at least one model has a problem")
    }
    
    XML_GETNODECHILD xmlNode:(verificationResult) nodeNumber:(5) result:xmlRersultsNode
    SETL sModelsList:("")
    XML_GETNODECHILDCOUNT xmlNode:(xmlRersultsNode) result:nModelCount

    #Check the presence of error tags
    IF (nModelCount = 1) {
        XML_GETNODECHILD xmlNode:(xmlRersultsNode) nodeNumber:(0) result:xmlRersultNode
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(0) result:xmlStatusNode
        XML_GETNODENAME xmlNode:(xmlStatusNode) result:sStatusNodeName
        IF (sStatusNodeName = "Status") {
            XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(1) result:xmlDescriptionNode
            XML_GETNODECONTENT xmlNode:(xmlDescriptionNode) result:sDescription
            XML_UNESCAPETEXTCONTENT xmlNodeContent:(sDescription) result:sDescription
            CC "AdoScript" ERRORBOX ("The verificator encountered an error.\n\n" + sDescription)
            EXIT
        }
    }
 
    #Load the list of verified models for which you want to see the results
    SETL indexModels:(0)
    WHILE (indexModels < nModelCount) {
        XML_GETNODECHILD xmlNode:(xmlRersultsNode) nodeNumber:(indexModels) result:xmlRersultNode
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(1) result:xmlModelIdNode

        XML_GETNODECONTENT xmlNode:(xmlModelIdNode) result:sModelNum
  
        IF (search(sModelNum,"_",0) != -1) {
            SETL sModelNum:(copy(sModelNum, search(sModelNum,"_",0)+1, LEN(sModelNum))
        }
        IF (search(sModelNum,".",0) != -1) {
            SETL sModelNum:(copy(sModelNum, search(sModelNum,".",0)+1, LEN(sModelNum))
        }
  
        SETL sModelsList:(sModelsList + STR(indexModels) + "- Model " + sModelNum)
        IF (indexModels + 1 < nModelCount) {
            SETL sModelsList:(sModelsList + ";")
        }
        SETL indexModels:(indexModels + 1)
    }
 
    WHILE (1) {
        CC "AdoScript" LISTBOX  entries: (sModelsList) toksep:";" title:"Models Verified" oktext:"Show me!" boxtext:"Select a model:"
        IF (endbutton != "ok") {
            BREAK
        }
  
        #Open and activate the selected model
        SETL nModelToShow:(VAL(copy(selection, 0, search(selection, "-", 0))))
        XML_GETNODECHILD xmlNode:(xmlRersultsNode) nodeNumber:(nModelToShow) result:xmlRersultNode
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(1) result:xmlModelIdNode
        XML_GETNODECONTENT xmlNode:(xmlModelIdNode) result:sModelNum
  
        IF (search(sModelNum,"_",0) != -1) {
            SETL sModelNum:(copy(sModelNum, search(sModelNum,"_",0)+1, LEN(sModelNum))
        }
        IF (search(sModelNum,".",0) != -1) {
            SETL sModelNum:(copy(sModelNum, search(sModelNum,".",0)+1, LEN(sModelNum))
        }
  
        CC "Modeling" OPEN modelids:(sModelNum)
        CC "Modeling" ACTIVATE_MODEL (VAL(sModelNum))
  
        #Show the verification result
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(2) result:xmlStatusNode
        XML_GETNODECONTENT xmlNode:(xmlStatusNode) result:sVerificationStatus
  
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(3) result:xmlStatusDescriptionNode
        XML_GETNODECONTENT xmlNode:(xmlStatusDescriptionNode) result:sVerificationStatusDescription
        XML_UNESCAPETEXTCONTENT xmlNodeContent:(sVerificationStatusDescription) result:sVerificationStatusDescription
  
        IF (sVerificationStatus = "OK") {
            CC "AdoScript" INFOBOX ("GOOD NEWS: " + sVerificationStatusDescription)
        } ELSE {
            CC "AdoScript" ERRORBOX ("BAD NEWS: "+sVerificationStatusDescription)
        }
        
        XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(4) result:xmlCounterExampleGuidelinesNode
        
        IF (xmlCounterExampleGuidelinesNode != "") {

            XML_GETNODENAME xmlNode:(xmlCounterExampleGuidelinesNode) result:xmlCounterExampleGuidelinesNodeName

            IF (xmlCounterExampleGuidelinesNodeName = "Guidelines") {
                
                #Load the list of the guidelines to show
                SETL sGuidelineList:("")
                XML_GETNODECHILDCOUNT xmlNode:(xmlCounterExampleGuidelinesNode) result:nGuidelinesCount
                SETL indexGuidelines:(0)
                FOR indexGuidelines from:(0) to:(nGuidelinesCount-1) {
                    XML_GETNODECHILD xmlNode:(xmlCounterExampleGuidelinesNode) nodeNumber:(indexGuidelines) result:xmlGuidelineNode
                    XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlGuidelineNode) attributeName:("id") result:sGuidelineId
                    XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlGuidelineNode) attributeName:("Name") result:sGuidelineName
                    SETL sGuidelineList:(sGuidelineList + STR(indexGuidelines) + "-" + sGuidelineId + " " + sGuidelineName)
                    IF (indexGuidelines + 1 < nGuidelinesCount) {
                        SETL sGuidelineList:(sGuidelineList + ";")
                    }
                }
                
                WHILE (1) {
                    CC "AdoScript" LISTBOX  entries: (sGuidelineList) toksep:";" title:"Guidelines list" oktext:"Show me!" boxtext:"Select a Guideline"
                    IF (endbutton != "ok") {
                        BREAK
                    }
                    #for te selected guideline show the description and suggestions and highlight the involved objects
                    SETL nGuidelineToShow:(VAL(copy(selection, 0, search(selection, "-", 0))))
                    XML_GETNODECHILD xmlNode:(xmlCounterExampleGuidelinesNode) nodeNumber:(nGuidelineToShow) result:xmlGuidelineNode
                    XML_GETNODECHILD xmlNode:(xmlGuidelineNode) nodeNumber:(0) result:xmlGuidelineDescriptionNode
                    XML_GETNODECONTENT xmlNode:(xmlGuidelineDescriptionNode) result:xmlGuidelineDescription
                    XML_UNESCAPETEXTCONTENT xmlNodeContent:(xmlGuidelineDescription) result:xmlGuidelineDescription
                    XML_GETNODECHILD xmlNode:(xmlGuidelineNode) nodeNumber:(1) result:xmlGuidelineSeggestionNode
                    XML_GETNODECONTENT xmlNode:(xmlGuidelineSeggestionNode) result:xmlGuidelineSeggestion
                    XML_UNESCAPETEXTCONTENT xmlNodeContent:(xmlGuidelineSeggestion) result:xmlGuidelineSeggestion
                    XML_GETNODECHILD xmlNode:(xmlGuidelineNode) nodeNumber:(2) result:xmlGuidelineElementsNode
                    #highlight the involved objects
                    CC "Modeling" DESELECT_ALL modelid:(VAL(sModelNum))
                    IF (xmlGuidelineElementsNode != "") {
                        XML_GETNODECHILDCOUNT xmlNode:(xmlGuidelineElementsNode) result:nElementIDCount
                        SETL indexElementID:(0)
                        FOR indexElementID from:(0) to:(nElementIDCount-1) {
                            XML_GETNODECHILD xmlNode:(xmlGuidelineElementsNode) nodeNumber:(indexElementID) result:xmlElementIDNode
                            XML_GETNODECONTENT xmlNode:(xmlElementIDNode) result:xmlElementID
                            IF (xmlElementID != "") {
                                SETL nObjectIdStart:(search(xmlElementID, ".", 0)+1)
                                SETL nObjectId:(VAL(copy(xmlElementID, nObjectIdStart, LEN(xmlElementID)-nObjectIdStart)))
                                CC "Modeling" SELECT objid:(nObjectId)
                            }
                        }
                    }
                    IF (xmlGuidelineSeggestion = "Well done!") {
                        CC "AdoScript" INFOBOX ("Guideline description:\n" + xmlGuidelineDescription + "\n\nSuggestions:\n" + xmlGuidelineSeggestion)
                    } ELSE {
                        CC "AdoScript" ERRORBOX ("Guideline description:\n" + xmlGuidelineDescription + "\n\nSuggestions:\n" + xmlGuidelineSeggestion + "\n\nThe affected elements are highlighted in the model.")
                    }
                    CC "Modeling" DESELECT_ALL modelid:(VAL(sModelNum))
                }
                
            } ELSIF (xmlCounterExampleGuidelinesNodeName = "CounterExampleTrace") {
            
                #Load the list of all found deadlock
                SETL sDeadlockList:("")
                XML_GETNODECHILDCOUNT xmlNode:(xmlRersultNode) result:nDeadlockCount
                SETL nDeadlockCount:(nDeadlockCount-4)

                SETL indexDeadlocks:(0)
                WHILE (indexDeadlocks < nDeadlockCount) {
                    SETL sDeadlockList:(sDeadlockList + STR(indexDeadlocks))
                    IF (indexDeadlocks + 1 < nDeadlockCount) {
                        SETL sDeadlockList:(sDeadlockList + ";")
                    }
                    SETL indexDeadlocks:(indexDeadlocks+1)
                }
                WHILE (1) {
                    CC "Modeling" DESELECT_ALL modelid:(VAL(sModelNum))

                    CC "AdoScript" LISTBOX  entries: (sDeadlockList) toksep:";" title:"Counterexample Traces" oktext:"Show me!" boxtext:"Select a Counterexample"
                    IF (endbutton != "ok") {
                        BREAK
                    }

                    #Show on the model the counter-trace of the selected deadlock, highlighting the objects involved in the trace
                    SETL nDeadlockToShow:(VAL(selection)+4)
                    XML_GETNODECHILD xmlNode:(xmlRersultNode) nodeNumber:(nDeadlockToShow) result:xmlDeadlockNode
                    XML_GETNODECHILDCOUNT xmlNode:(xmlDeadlockNode) result:nStepsCount

                    #Parse each counter example step. Each step contain all the objects that run in parallel
                    SETL indexSteps:(0)
                    WHILE (indexSteps < nStepsCount) {
                        XML_GETNODECHILD xmlNode:(xmlDeadlockNode) nodeNumber:(indexSteps) result:xmlStepNode
                        XML_GETNODECHILDCOUNT xmlNode:(xmlStepNode) result:nObjectCount
         
                        #Get every object present in a step and select it
                        SETL indexObjects:(0)
                        WHILE (indexObjects < nObjectCount) {
                            XML_GETNODECHILD xmlNode:(xmlStepNode) nodeNumber:(indexObjects) result:xmlObjectNode
                            XML_GETNODECONTENT xmlNode:(xmlObjectNode) result:sObjectIdFull
                            SETL nObjectIdStart:(search(sObjectIdFull, ".", 0)+1)
                            SETL nObjectId:(VAL(copy(sObjectIdFull, nObjectIdStart, LEN(sObjectIdFull)-nObjectIdStart)))
          
                            CC "Modeling" GET_SELECTED modelid:(VAL(sModelNum))
                            IF (search(objids, STR(nObjectId), 0) = -1) {
                                CC "Modeling" SELECT objid:(nObjectId)
                                CC "AdoScript" SLEEP ms: (500)
                            }

                            IF (indexSteps + 1 >= nStepsCount) {
                                CC "Modeling" DESELECT objid:(nObjectId)
                                CC "AdoScript" SLEEP ms: (250)
                                CC "Modeling" SELECT objid:(nObjectId)
                                CC "AdoScript" SLEEP ms: (250)
                                CC "Modeling" DESELECT objid:(nObjectId)
                                CC "AdoScript" SLEEP ms: (250)
                                CC "Modeling" SELECT objid:(nObjectId)
                            }
          
                            SETL indexObjects:(indexObjects+1)
                        }
                        SETL indexSteps:(indexSteps+1)
                    }
                    #Give some seconds to the user for seeing the trace
                    CC "AdoScript" SLEEP ms: (5000)
                }
                
            } ELSE {
                CC "AdoScript" INFOBOX ("XML TAG NOT RECOGNIZED:\n" + xmlCounterExampleGuidelinesNode)
            }
        }
    }
}

#Parse the Feedback and Patches adding them to the model
PROCEDURE global LP_SHOW_FEEDBACKS_AND_PATCHES sFeedbacks: string {
    XML_GETNODECHILD xmlNode:(sFeedbacks) nodeNumber:(0) result:xmlPatchesNode
    XML_GETNODECHILD xmlNode:(sFeedbacks) nodeNumber:(1) result:xmlFeedbacksNode
    XML_GETNODECHILDCOUNT xmlNode:(xmlPatchesNode) result:nPatchesNodes
    XML_GETNODECHILDCOUNT xmlNode:(xmlFeedbacksNode) result:nFeedbacksNodes
    #Parse all patches
    FOR indexPatchesNode from:(0) to:(nPatchesNodes-1) {
        XML_GETNODECHILD xmlNode:(xmlPatchesNode) nodeNumber:(indexPatchesNode) result:xmlPatchNode
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlPatchNode) attributeName:("type") result:sPatchType
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlPatchNode) attributeName:("modelid") result:sModelId
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlPatchNode) attributeName:("id") result:sPatchId
        #open the model
        CC "Modeling" OPEN modelids:(sModelId)
        CC "Modeling" ACTIVATE_MODEL (VAL(sModelId))
        #parse all the artefact
        XML_GETNODECHILDCOUNT xmlNode:(xmlPatchNode) result:nArtefactNodes
        FOR indexArtefactNode from:(0) to:(nArtefactNodes-1) {
            XML_GETNODECHILD xmlNode:(xmlPatchNode) nodeNumber:(indexArtefactNode) result:xmlArtefactNode
            XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlArtefactNode) attributeName:("id") result:sArtefactId
            XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlArtefactNode) attributeName:("name") result:sArtefactName
            XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlArtefactNode) attributeName:("className") result:sArtefactClassName
            #If is a delete, remove the object and continue
            IF (sPatchType="delete") {
                CC "Modeling" DESELECT_ALL modelid:(VAL(sModelId))
                CC "Modeling" SELECT objid:(VAL sArtefactId)
                CC "AdoScript" WARNINGBOX ("The patch "+sPatchId+" want to delete the highlighted object " + sArtefactId + ". Do you want to proceed?") yes-no
                IF (endbutton="yes") {
                    CC "Core" DELETE_OBJS modelid:(VAL sModelId) objids:(sArtefactId)
                    IF (ecode!=0) {
                        CC "AdoScript" ERRORBOX ("Impossible to delete the object " + sArtefactId)
                    }
                }
                CC "Modeling" DESELECT_ALL modelid:(VAL(sModelId))
                NEXT
            }
            #If is an add, create the object and then insert the attributes
            IF (sPatchType="add") {
                CC "AdoScript" WARNINGBOX ("Do you want to create an object with name " + sArtefactName + "?") yes-no
                IF (endbutton!="yes") {
                    NEXT
                }
                CC "Core" GET_CLASS_ID classname:(sArtefactClassName)
                CC "Core" CREATE_OBJ modelid:(VAL sModelId) classid:(classid) objname:(sArtefactName)
                IF (ecode!=0) {
                    CC "AdoScript" ERRORBOX ("Impossible to create the object " + sArtefactName)
                    NEXT
                }
            }
            #In the edit case I have to update the name of the object and then all the attributes
            IF (sPatchType="edit") {
                CC "Modeling" DESELECT_ALL modelid:(VAL(sModelId))
                CC "Modeling" SELECT objid:(VAL sArtefactId)
                CC "AdoScript" WARNINGBOX ("Do you want to edit the object with name " + sArtefactName + "?") yes-no
                CC "Modeling" DESELECT_ALL modelid:(VAL(sModelId))
                IF (endbutton!="yes") {
                    NEXT
                }
                CC "Core" SET_ATTR_VAL objid:(VAL sArtefactId) attrname:("Name") val:(sArtefactName)
            }
            #In any case (except delete) I have to update the attributes with the one provided
            XML_GETNODECHILDCOUNT xmlNode:(xmlArtefactNode) result:nAttributeNodes
            FOR indexAttributeNode from:(0) to:(nAttributeNodes-1) {
                XML_GETNODECHILD xmlNode:(xmlArtefactNode) nodeNumber:(indexAttributeNode) result:xmlAttributeNode
                XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlAttributeNode) attributeName:("id") result:sAttributeId
                XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlAttributeNode) attributeName:("name") result:sAttributeName
                XML_GETNODECONTENT xmlNode:(xmlAttributeNode) result:sAttributeValue
                CC "Core" SET_ATTR_VAL objid:(VAL sArtefactId) attrname:(sAttributeName) val:(sAttributeValue)
                IF (ecode!=0) {
                    CC "AdoScript" ERRORBOX ("Impossible to set the attribute "+sAttributeName+" for the object " + sArtefactId + " with value "+sAttributeValue)
                }
            }
        }
        #Save the model
        CC "Core" SAVE_MODEL modelid:(VAL sModelId)
    }
    
    #Parse all feedbacks
    FOR indexFeedbackNode from:(0) to:(nFeedbacksNodes-1) {
        XML_GETNODECHILD xmlNode:(xmlFeedbacksNode) nodeNumber:(indexFeedbackNode) result:xmlFeedbackNode
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlFeedbackNode) attributeName:("artefactid") result:sArtifactId
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlFeedbackNode) attributeName:("modelid") result:sModelId
        XML_GETNODEATTRIBUTEVALUE xmlNode:(xmlFeedbackNode) attributeName:("id") result:sFeedbackId
        XML_GETNODECONTENT xmlNode:(xmlFeedbackNode) result:sFeedback
        #open the model
        CC "Modeling" OPEN modelids:(sModelId)
        CC "Modeling" ACTIVATE_MODEL (VAL(sModelId))
        #build a string for the comment box object name
        CC "UserMgt" GET_USER_ID_OF_CURRENT_USER
		CC "UserMgt" GET_USER_NAME userid:(userid)
		SETL sCommentBoxObjName:("User: " + username)
		CC "Application" GET_DATE_TIME date-format:"DD.MM.YYYY" time-format:"HH:MM:SS"
        SETL sCommentBoxObjName:(STR(indexFeedbackNode)+" "+sFeedbackId+" "+sCommentBoxObjName+" "+date+" "+time)
        #create a comment box obj
        CC "Core" GET_CLASS_ID classname:("Comment Box")
        CC "Core" CREATE_OBJ modelid:(VAL sModelId) classid:(classid) objname:(sCommentBoxObjName)
        IF (ecode!=0) {
            CC "AdoScript" ERRORBOX ("Impossible to create the Comment Box with name:" + sCommentBoxObjName + " for the object " + sArtifactId)
            NEXT
        }
        SETL nCommentObjId:(objid)
        CC "Core" SET_ATTR_VAL objid:(nCommentObjId) attrname:("Comment") val:(sFeedback)
		#connect the comment box with the artifact
		CC "Core" GET_CLASS_ID classname:("ObjectToComment")
		SETL nTask2CommId:(classid)
        CC "Core" CREATE_CONNECTOR modelid:(VAL sModelId) fromobjid:(VAL sArtifactId) toobjid:(nCommentObjId) classid:(nTask2CommId)
		SETL nConnectorId:(objid)
        #get the artifact position
        CC "Core" GET_CLASS_ID objid:(VAL sArtifactId)
        CC "Core" GET_ATTR_ID classid:(classid) attrname:("Position") 
        CC "Core" GET_ATTR_VAL objid:(VAL sArtifactId) attrid:(attrid)
        SETL sArtifactPosition:(val)
        LEO parse:(sArtifactPosition) get-tmm-value:n_x_refobj:"x" get-tmm-value:n_y_refobj:"y"
        SETL nArtifactPositionX: ((n_x_refobj) + CM 7)
		SETL nArtifactPositionY: ( (n_y_refobj))
        #Set the comment box position
        CC "Core" GET_OBJ_NAME objid:(VAL sArtifactId)
        CC "Core" GET_CLASS_ID objid:(VAL sArtifactId)
        CC "Core" GET_CLASS_NAME classid:(classid)
        CC "AQL"  EVAL_AQL_EXPRESSION expr: ("{\""+(objname)+"\":\""+classname+"\"} -> \"ObjectToComment\"") modelid:(VAL sModelId)
        SETL nCommentBoxCount:(tokcnt (objids))
        CC "Modeling" SET_OBJ_POS objid:(nCommentObjId) x:(nArtifactPositionX) y:(nArtifactPositionY + (nCommentBoxCount-1) * CM 2.1)
        #Set Relation Bend point
        CC "Core" GET_ATTR_ID classid:(nTask2CommId) attrname:("Positions")
        CC "Core" SET_ATTR_VAL objid:(n_ConnectorId) attrid:(attrid) val:("EDGE 1 x1:9.5cm y1:" + STR(nArtifactPositionY))
        #Save the model
        CC "Core" SAVE_MODEL modelid:(VAL sModelId)
    }
}


#XMLUtils procedure collections:
# PROCEDURE global XML_SANITIZE xmlNode: string result: reference
# PROCEDURE global XML_GETNODENAME xmlNode: string result: reference
# PROCEDURE global XML_GETNODECONTENT xmlNode: string result: reference
# PROCEDURE global XML_UNESCAPETEXTCONTENT xmlNodeContent: string result: reference
# PROCEDURE global XML_GETNODEFIRSTCHILD xmlNode: string result: reference
# PROCEDURE global XML_GETNODECHILD xmlNode: string nodeNumber: integer result: reference
# PROCEDURE global XML_GETNODECHILDCOUNT xmlNode: string result: reference
# PROCEDURE global XML_GETNODEATTRIBUTENAMELIST xmlNode: string result: reference
# PROCEDURE global XML_GETNODEATTRIBUTEVALUE xmlNode: string attributeName: string result: reference

#Remove all the comments and headers in an XML string
PROCEDURE global XML_SANITIZE xmlNode: string result: reference {
    WHILE (search(xmlNode, "<!--", 0) != -1) {
        SETL nStart:(search(xmlNode, "<!--", 0))
        SETL nEnd:(search(xmlNode, "-->", nStart+4)+3)
        SETL xmlNode:(copy(xmlNode, 0, nStart) + copy(xmlNode, nEnd, LEN(xmlNode)-nEnd))
    }
    IF (search(xmlNode, "<?", 0) != -1) {
        SETL nStart:(search(xmlNode, "<?", 0))
        SETL nEnd:(search(xmlNode, ">", nStart)+1)
        SETL xmlNode:(copy(xmlNode, 0, nStart) + copy(xmlNode, nEnd, LEN(xmlNode)-nEnd))
    }
    IF (search(xmlNode, "<!DOCTYPE", 0) != -1) {
        SETL nStart:(search(xmlNode, "<!DOCTYPE", 0))
        SETL nEnd:(search(xmlNode, ">", nStart)+1)
        SETL xmlNode:(copy(xmlNode, 0, nStart) + copy(xmlNode, nEnd, LEN(xmlNode)-nEnd))
    }
    SETL result:(xmlNode)
}

#Get the node name of the root in the xml string passed as parameter
PROCEDURE global XML_GETNODENAME xmlNode: string result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode
  
    SETL nStart:(search(xmlNode, "<", 0)+1)
    SETL nEnd:(search(xmlNode, ">", nStart))
    SETL result:(copy(xmlNode, nStart, nEnd-nStart))
    IF (search(result," ",0) != -1) {
        SETL result:(copy(result, 0, search(result," ",0)))
    }
    IF (search(result,"/",0) != -1) {
        SETL result:(copy(result, 0, search(result,"/",0)))
    }
}

#Get the full node content of the root in the xml string passed as parameter; if the node is like <node a="1"/> return empty content
PROCEDURE global XML_GETNODECONTENT xmlNode: string result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode

    XML_GETNODENAME xmlNode:(xmlNode) result:sName
    SETL nStart:(search(xmlNode, ">", 0)+1)
    SETL nEnd:(search(xmlNode, "</"+sName+">", 0))
    SETL result:(copy(xmlNode, nStart, nEnd-nStart))
}

#Unescape the content of a text node extracting the text inside <![CDATA[]]> and converting &lt; &gt; &amp; &apos; and &quot;
PROCEDURE global XML_UNESCAPETEXTCONTENT xmlNodeContent: string result: reference {
    XML_SANITIZE xmlNode:(xmlNodeContent) result:xmlNodeContent

    IF (search(xmlNodeContent, "<![CDATA[", 0)!=-1) {
        SETL nStart:(search(xmlNodeContent, "<![CDATA[", 0)+LEN("<![CDATA["))
        SETL nEnd:(search(xmlNodeContent, "]]>", 0))
        SETL result:(copy(xmlNodeContent, nStart, nEnd-nStart))
    } ELSE {
        SETL xmlNodeContent:(replall(xmlNodeContent, "&lt;", "<"))
        SETL xmlNodeContent:(replall(xmlNodeContent, "&gt;", ">"))
        SETL xmlNodeContent:(replall(xmlNodeContent, "&amp;", "&"))
        SETL xmlNodeContent:(replall(xmlNodeContent, "&apos;", "'"))
        SETL xmlNodeContent:(replall(xmlNodeContent, "&quot;", "\""))
        SETL result:(xmlNodeContent)
    }
}

#Get the first child node of the root node in the xml string passed as parameter
PROCEDURE global XML_GETNODEFIRSTCHILD xmlNode: string result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode
    XML_GETNODECONTENT xmlNode:(xmlNode) result:sContent
    XML_GETNODENAME xmlNode:(sContent) result:sFirstNodeName
    SETL nStart:(search(sContent, "<"+sFirstNodeName, 0))
    IF (search(sContent, "</"+sFirstNodeName+">", 0) != -1) {
        SETL nEnd:(search(sContent, "</"+sFirstNodeName+">", nStart) + LEN("</"+sFirstNodeName+">"))
    } ELSE {
        SETL nEnd:(search(sContent, "/>", nStart) + 2)
    }
    SETL result:(copy(sContent, nStart, nEnd-nStart))
}

#Get the child node indexed as nodeNumber of the root in the xml string passed as parameter
PROCEDURE global XML_GETNODECHILD xmlNode: string nodeNumber: integer result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode
    SETL tmpXmlNode:(xmlNode)
    SETL index:(0)
    WHILE (1) {
        XML_GETNODEFIRSTCHILD xmlNode:(tmpXmlNode) result:sFirstNode
        IF (search(sFirstNode,"<",0) = -1) {
            SETL result:("")
            BREAK
        }
        IF (nodeNumber = index) {
            SETL result:(sFirstNode)
            BREAK
        }
        SETL nStart:(search(tmpXmlNode, sFirstNode, 0))
        SETL nEnd:(nStart + LEN(sFirstNode))
        SETL tmpXmlNode:(copy(tmpXmlNode, 0, nStart) + copy(tmpXmlNode, nEnd, LEN(tmpXmlNode)-nEnd))
        SETL index:(index+1)
    }
}

#Get the childs node count of the root in the xml string passed as parameter
PROCEDURE global XML_GETNODECHILDCOUNT xmlNode: string result: reference {
    SETL count:(0)
    WHILE (1) {
        XML_GETNODECHILD xmlNode:(xmlNode) nodeNumber:(count) result:ret
        IF (ret = "") {
            BREAK
        }
        SETL count:(count+1)
    }
    SETL result:(count)
}

#Get a list with the name of all attributes name presents in the root in the xml string passed as parameter
PROCEDURE global XML_GETNODEATTRIBUTENAMELIST xmlNode: string result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode
    XML_GETNODENAME xmlNode:(xmlNode) result:sNodeName
    SETL nStart:(search(xmlNode, "<"+sNodeName, 0)+LEN("<"+sNodeName))
    SETL nEnd:(search(xmlNode, ">", 0))
    SETL sAttrRaw:(copy(xmlNode, nStart, nEnd-nStart))
    SETL sRes:("")
    WHILE (1) {
        IF (search(sAttrRaw, "\"", 0) = -1) {
            BREAK
        }
        SETL nStart:(search(sAttrRaw, "\"", 0)+1)
        SETL nEnd:(search(sAttrRaw, "\"", nStart))
  
        SETL sAttrName:(copy(sAttrRaw, 0, nStart-1))
        WHILE (search(sAttrName, " ", 0) != -1) {
            SETL sAttrName:(replall(sAttrName, " ", ""))
        }
        SETL sAttrName:(copy(sAttrName, 0, LEN(sAttrName)-1))  
    
        SETL sRes:(sRes + " " + sAttrName)

        SETL sAttrRaw:(copy(sAttrRaw, nEnd+1, LEN(sAttrRaw)-nEnd-1))
    }
    
    IF (sRes != "") {
        SETL sRes:(copy(sRes, 1, LEN(sRes)-1))
    }
    
    SETL result:(sRes)
}

#Get the value of the attribute specified with attributeName presents in the root in the xml string passed as parameter
PROCEDURE global XML_GETNODEATTRIBUTEVALUE xmlNode: string attributeName: string result: reference {
    XML_SANITIZE xmlNode:(xmlNode) result:xmlNode
    XML_GETNODENAME xmlNode:(xmlNode) result:sNodeName
    SETL nStart:(search(xmlNode, "<"+sNodeName, 0)+LEN("<"+sNodeName))
    SETL nEnd:(search(xmlNode, ">", 0))
    SETL sAttrRaw:(copy(xmlNode, nStart, nEnd-nStart))
    SETL sRes:("")
    WHILE (1) {
        IF (search(sAttrRaw, "\"", 0) = -1) {
            BREAK
        }
        SETL nStart:(search(sAttrRaw, "\"", 0)+1)
        SETL nEnd:(search(sAttrRaw, "\"", nStart))
  
        SETL sAttrName:(copy(sAttrRaw, 0, nStart-1))
        WHILE (search(sAttrName, " ", 0) != -1) {
            SETL sAttrName:(replall(sAttrName, " ", ""))
        }
        SETL sAttrName:(copy(sAttrName, 0, LEN(sAttrName)-1))  
        SETL sAttrValue:(copy(sAttrRaw, nStart, nEnd-nStart))
  
        IF (attributeName = sAttrName) {
            SETL sRes:(sAttrValue)
            BREAK
        }
        SETL sAttrRaw:(copy(sAttrRaw, nEnd+1, LEN(sAttrRaw)-nEnd-1))
    }
    SETL result:(sRes)
}

PROCEDURE global EXPORT_XML_MODEL result: reference {
    CC "AdoScript" GET_TEMP_FILENAME
    SETL sTempFolder:(copy(filename, 0, bsearch(filename, "\\", (LEN filename)-1)+1))

    SETL sTempModelSetPath:(sTempFolder+"adoxx_modelset.xml")

    CC "ImportExport" SHOW_EXPORT_DLG mode: "xml" title: "Select a Model Set to convert" filedescription: "xml" fileextension: "*.xml" filename: (sTempModelSetPath)
    IF (endbutton != "ok") {
        EXIT
    }
    SETL sModelIDList:(modelids)
    SETL sTempModelSetPath:(filename)
    
    #Export the whole xml
    CC "Documentation" XML_MODELS modelids: (sModelIDList) mgroupids: ("") attrprofs: ("") apgroups: ("") 
    IF (ecode != 0) {
        CC "AdoScript" ERRORBOX ("Error exporting the models")
        SETL result:("KO")
        EXIT
    }

    SETL sFullXml:(xml)
    SETL sFullXml:(replall(sFullXml, "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n", ""))
    SETL sFullXml:(replall(sFullXml, " xmlns=\"@boc-eu.com/boc-is/adonis.model.document;1\"", ""))
    SETL sFullXml:(replall(sFullXml, " xsi:schemaLocation=\"@boc-eu.com/boc-is/adonis.model.document;1 adoxmlmodel.xsd\"", ""))
    SETL sFullXml:(replall(sFullXml, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"", ""))
    CC "AdoScript" FWRITE file: (sTempModelSetPath) text: (sFullXml) append: 0 binary: 0 base64: 0
    CC "AdoScript" FREAD file: (sTempModelSetPath)
    IF (text = "") {
        CC "AdoScript" ERRORBOX ("Failure on the creation of the file: " + sTempModelSetPath)
        SETL result:("KO")
        EXIT
    }

    SETL result:("OK")
}